#include "mainwindow.h"

MainWindow::MainWindow()
: _currentInmersion( NULL ), _buceador( NULL )
{
    _datastore = new DataStore();

    _inmersionesModel = new InmersionesModel( _datastore );
    _estadisticasModel = new EstadisticasModel( _datastore );

    _inmersionesList = new InmersionesList( this, _inmersionesModel, _estadisticasModel );
    connect( _inmersionesList, SIGNAL( currentIndexChanged( const QModelIndex& ) ), this, SLOT( currentInmersionChanged( const QModelIndex& ) ) );
    connect( _inmersionesList, SIGNAL( inmersionesToggle( bool ) ), this, SLOT( inmersionesListToggle( bool ) ) );

    _inmersionDetalles = new InmersionDetalles( this );
    _inmersionGrafico = new InmersionGrafico( this, _datastore );

    _statusbar = statusBar();
    _statusbar->setSizeGripEnabled( false );

    _menubar = menuBar();
    _menubar->setObjectName( "mainMenu" );

    createActions();
    createMenus();
    createDocks();

    _inmersionesList->setMinimumSize( 250, 400 );
    _inmersionDetalles->setMinimumSize( 350, 250 );
    _inmersionGrafico->setMinimumSize( 200, 200 );
    setContentsMargins( 10, 5, 10, 5 );

    setCentralWidget( _inmersionGrafico );

    QSettings settings;
    if( settings.contains( "geometry" ) && settings.contains( "state" ) )
    {
        restoreGeometry( settings.value( "geometry" ).toByteArray() );
        restoreState( settings.value( "state" ).toByteArray());
    }
    else setGeometry( (0.1*QApplication::desktop()->width()), (0.1*QApplication::desktop()->height()),
                      (0.8*QApplication::desktop()->width()), (0.8*QApplication::desktop()->height()) );

    _fullscreenAction->setChecked( isFullScreen() );
    _inmersionesListToggleAction->setChecked( _inmersionesListDock->isEnabled() );
    _inmersionDetallesToggleAction->setChecked( _inmersionDetallesDock->isEnabled() );

    sort( _sortInicioDescAction );
    _login = new Login( this, (&_datastore->buceadores()) );
}

void MainWindow::currentInmersionChanged( const QModelIndex& index )
{
    _currentInmersion = _inmersionesModel->inmersion( index );
    _inmersionDetallesStack->setCurrentIndex(1);
    _inmersionDetalles->showDetalles( _currentInmersion );
    switch( _inmersionGrafico->showGrafico( _currentInmersion ) )
    {
        case InmersionGrafico::Profundidad:
            _verProfundidadAction->setChecked( true );
            break;
        case InmersionGrafico::Temperatura:
            _verTemperaturaAction->setChecked( true );
            break;
        case InmersionGrafico::Presion:
            _verPresionAction->setChecked( true );
            break;
        case InmersionGrafico::TasaCAS:
            _verTasaCasAction->setChecked( true );
            break;
    }
    if( _currentInmersion )
    {
        _inmersionDetallesDock->setWindowTitle( trUtf8("Detalles de %1").arg( _currentInmersion->sitio()->nombre() ) );
        _inmersionesList->setCurrentIndex( index );
        _eliminarAction->setText( trUtf8("Eliminar %1").arg( _currentInmersion->sitio()->nombre() ) );
        _eliminarAction->setStatusTip( trUtf8("Eliminar la inmersión %1").arg( _currentInmersion->sitio()->nombre() ) );
    }
    else
    {
        _inmersionDetallesDock->setWindowTitle( trUtf8( "Detalles" ) );
        _eliminarAction->setText( trUtf8( "Eliminar" ) );
        _eliminarAction->setStatusTip( trUtf8( "Eliminar la inmersión seleccionada" ) );
    }
    _verActions->setEnabled( _currentInmersion );
    _sortActions->setEnabled( _currentInmersion );
    _verMapaToggleAction->setChecked( false );
    _verMapaToggleAction->setEnabled( _currentInmersion );
    _eliminarAction->setEnabled( _currentInmersion );
    _ordenarMenu->setEnabled( _currentInmersion );
}

void MainWindow::eliminarInmersion()
{
    QString nombre = _currentInmersion->sitio()->nombre();
    /*QMessageBox question;
    question.setText( trUtf8( "¿Eliminar %1?").arg( nombre ) );
    question.setStandardButtons( QMessageBox::Yes | QMessageBox::No );
    question.setDefaultButton( QMessageBox::No );
    if( question.exec() == QMessageBox::Yes )
    {*/
        if( _inmersionesModel->removeRow( _inmersionesList->currentIndex().row() ) )
        {
            quint32 count = _buceador->inmersiones().count();
            if( count == 1 )
                _statusbar->showMessage( trUtf8("Inmersión \"%1\" eliminada - Queda 1 inmersión").arg( nombre ), 10000 );
            else _statusbar->showMessage( trUtf8("Inmersión \"%1\" eliminada - Quedan %2 inmersiones").arg( nombre ).arg( count ), 10000 );
        }
    /*}*/
}

void MainWindow::chooseBuceador()
{
    if( _buceador )
    {
        _inmersionesModel->clearInmersiones();
        _buceador = NULL;
    }
    _login->resize( size() );
    _login->show();
    show();
}

void MainWindow::showBuceador( const QString& usuario )
{
    _buceador = _datastore->buceador( usuario );
    if( !_buceador )
    {
        qWarning() << "Cannot find buceador called" << usuario;
        chooseBuceador();
        return;
    }
    _estadisticasModel->loadEstadisticas( _buceador );
    quint32 count = _inmersionesModel->loadInmersiones( _buceador );
    _statusbar->showMessage( trUtf8("Cargado %1 inmersiones para usuario %2").arg( count ).arg( _buceador->usuario() ) );
    _inmersionGrafico->setBuceador( _buceador );
    QWidget::show();
    _inmersionesList->setFocus();
}

void MainWindow::mapaToggle( bool visible )
{
    _inmersionGrafico->verMapa( visible );
    if( _currentInmersion ) _verActions->setEnabled( !visible );
}

void MainWindow::estadisticasToggle( bool visible )
{
    if( visible )
        _inmersionesList->showEstadisticas();
    else
        _inmersionesList->showInmersiones( QModelIndex() );
}

void MainWindow::inmersionesListToggle( bool visible )
{
    _verMapaToggleAction->setChecked( !visible );
    _verEstadisticasAction->setChecked( !visible );
}

void MainWindow::closeEvent( QCloseEvent* event )
{
    QSettings settings;
    settings.setValue( "geometry", saveGeometry() );
    settings.setValue( "state", saveState() );
    QMainWindow::closeEvent( event );
}

void MainWindow::importInmersiones()
{
    QString importpath = QFileDialog::getExistingDirectory(
                this,
                trUtf8( "Importar inmersiones - Elegir carpeta" ),
                QStandardPaths::standardLocations( QStandardPaths::DesktopLocation ).first(),
                QFileDialog::ShowDirsOnly
    );
    if( !importpath.isEmpty() )
    {
        QElapsedTimer timer; timer.start();
        QDir importdir( importpath );
        QStringList importfiles = importdir.entryList( QStringList( "*.xml" ), QDir::Files );
        for( int i = 0; i < importfiles.size(); ++i ) _datastore->importXml( _buceador, importdir.absoluteFilePath( importfiles.at(i) ), true );
        _inmersionesModel->loadInmersiones( _buceador );
        qDebug() << timer.elapsed() << "ms";
    }
}

void logfunc( dc_context_t* /*context*/,
              dc_loglevel_t /*loglevel*/,
              const char* /*file*/,
              unsigned int /*line*/,
              const char* /*function*/,
              const char* /*msg*/,
              void* /*userdata*/ )
{}

void MainWindow::importReloj()
{
    qDebug() << "reloj";

    dc_context_t* context = NULL;
    dc_device_t* device = NULL;

    dc_context_new( &context );
    dc_context_set_loglevel( context, DC_LOGLEVEL_ALL );
    dc_context_set_logfunc( context, logfunc, NULL );

    qDebug() << "suunto_d9_device_open";
    dc_status_t rc = suunto_d9_device_open( &device, context, "reloj", 0 );
    if( rc != DC_STATUS_SUCCESS )
    {
        qDebug() << "Error opening serial port";
        dc_context_free( context );
        return;
    }

    qDebug() << "dc_device_foreach";
    rc = dc_device_foreach( device, NULL, NULL );
    if( rc != DC_STATUS_SUCCESS )
    {
        qDebug() << "Cannot read dives";
        dc_device_close( device );
        dc_context_free( context );
        return;
    }

    qDebug() << "dc_device_close";
    rc = dc_device_close( device );
    if( rc != DC_STATUS_SUCCESS )
    {
        qDebug() << "Cannot close device";
        dc_context_free( context );
        return;
    }

    dc_context_free( context );
}

void MainWindow::importMuestras()
{
    QString importpath = QFileDialog::getExistingDirectory(
                this,
                trUtf8( "Importar muestras - Elegir carpeta" ),
                QStandardPaths::standardLocations( QStandardPaths::DesktopLocation ).first(),
                QFileDialog::ShowDirsOnly
    );
    if( !importpath.isEmpty() )
    {
        QElapsedTimer timer; timer.start();
        QDir importdir( importpath );
        QStringList importfiles = importdir.entryList( QStringList( "*.xml" ), QDir::Files );
        for( int i = 0; i < importfiles.size(); ++i ) _datastore->importXml( _buceador, importdir.absoluteFilePath( importfiles.at(i) ) );
        qDebug() << timer.elapsed() << "ms";
    }
}

void MainWindow::toggleFullscreen()
{
    if( isFullScreen() )
    {
        showNormal();
        _fullscreenAction->setChecked( false );
    }
    else
    {
        showFullScreen();
        _fullscreenAction->setChecked( true );
    }
}

void MainWindow::sort( QAction* action )
{
    action->setChecked( true );
    if( action == _sortInicioAscAction )
    {
        _inmersionesModel->setSortRole( InmersionesSourceModel::NumeroRole );
        _inmersionesModel->sort( 0, Qt::AscendingOrder );
    }
    else if( action == _sortInicioDescAction )
    {
        _inmersionesModel->setSortRole( InmersionesSourceModel::NumeroRole );
        _inmersionesModel->sort( 0, Qt::DescendingOrder );
    }
    if( action == _sortSitioAscAction )
    {
        _inmersionesModel->setSortRole( InmersionesSourceModel::SitioRole );
        _inmersionesModel->sort( 0, Qt::AscendingOrder );
    }
    if( action == _sortSitioDescAction )
    {
        _inmersionesModel->setSortRole( InmersionesSourceModel::SitioRole );
        _inmersionesModel->sort( 0, Qt::DescendingOrder );
    }
    if( action == _sortDuracionAscAction )
    {
        _inmersionesModel->setSortRole( InmersionesSourceModel::DuracionRole );
        _inmersionesModel->sort( 0, Qt::AscendingOrder );
    }
    if( action == _sortDuracionDescAction )
    {
        _inmersionesModel->setSortRole( InmersionesSourceModel::DuracionRole );
        _inmersionesModel->sort( 0, Qt::DescendingOrder );
    }
    if( action == _sortHoraAscAction )
    {
        _inmersionesModel->setSortRole( InmersionesSourceModel::HoraRole );
        _inmersionesModel->sort( 0, Qt::AscendingOrder );
    }
    if( action == _sortHoraDescAction )
    {
        _inmersionesModel->setSortRole( InmersionesSourceModel::HoraRole );
        _inmersionesModel->sort( 0, Qt::DescendingOrder );
    }
    _inmersionesList->scrollTo( _inmersionesList->currentIndex() );
}

void MainWindow::inmersionesListDockToggle( bool visible )
{
    _inmersionesListToggleAction->setChecked( visible );
    _inmersionesListDock->setVisible( visible );
}

void MainWindow::inmersionDetallesDockToggle( bool visible )
{
    _inmersionDetallesToggleAction->setChecked( visible );
    _inmersionDetallesDock->setVisible( visible );
}

void MainWindow::resizeEvent( QResizeEvent* event )
{
    if( _login->isVisible() ) _login->resize( event->size() );
}

void MainWindow::createActions()
{
    _chooseBuceadorAction = new QAction( trUtf8("Cambiar usuario"), this );
    _chooseBuceadorAction->setShortcut( trUtf8("Ctrl+U") );
    _chooseBuceadorAction->setStatusTip( trUtf8("Mostrar las inmersiones de otro buceador") );
    _chooseBuceadorAction->setShortcutContext( Qt::ApplicationShortcut );
    connect( _chooseBuceadorAction, SIGNAL( triggered() ), this, SLOT( chooseBuceador() ) );
    addAction( _chooseBuceadorAction );

    _importRelojAction = new QAction( trUtf8("Importar datos de reloj de buceo"), this );
    _importRelojAction->setShortcut( trUtf8("Ctrl+I") );
    _importRelojAction->setStatusTip( trUtf8("Importar los datos de un reloj de buceo") );
    _importRelojAction->setShortcutContext( Qt::ApplicationShortcut );
    connect( _importRelojAction, SIGNAL( triggered() ), this, SLOT( importReloj() ) );
    addAction( _importRelojAction );

    _importInmersionesAction = new QAction( trUtf8("Importar inmersiones"), this );
    _importInmersionesAction->setShortcut( trUtf8("Ctrl+Shift+I") );
    _importInmersionesAction->setStatusTip( trUtf8("Importar las inmersiones de los ficheros xml de una carpeta") );
    _importInmersionesAction->setShortcutContext( Qt::ApplicationShortcut );
    connect( _importInmersionesAction, SIGNAL( triggered() ), this, SLOT( importInmersiones() ) );
    addAction( _importInmersionesAction );

    _importMuestrasAction = new QAction( trUtf8("Importar muestras"), this );
    _importMuestrasAction->setShortcut( trUtf8("Ctrl+Alt+I") );
    _importMuestrasAction->setStatusTip( trUtf8("Importar las muestras de los ficheros xml de una carpeta") );
    _importMuestrasAction->setShortcutContext( Qt::ApplicationShortcut );
    connect( _importMuestrasAction, SIGNAL( triggered() ), this, SLOT( importMuestras() ) );
    addAction( _importMuestrasAction );

    _salirAction = new QAction( trUtf8("Salir"), this );
    _salirAction->setShortcut( QKeySequence::Quit );
    _salirAction->setStatusTip( trUtf8("Salir de la aplicación") );
    _salirAction->setShortcutContext( Qt::ApplicationShortcut );
    connect( _salirAction, SIGNAL( triggered() ), qApp, SLOT( closeAllWindows() ) );
    addAction( _salirAction );

    _eliminarAction = new QAction( trUtf8("Eliminar"), this );
    _eliminarAction->setShortcut( Qt::Key_Delete );
    _eliminarAction->setStatusTip( trUtf8("Eliminar la inmersión seleccionada") );
    _eliminarAction->setShortcutContext( Qt::ApplicationShortcut );
    _eliminarAction->setEnabled( false );
    connect( _eliminarAction, SIGNAL( triggered() ), this, SLOT( eliminarInmersion() ) );
    addAction( _eliminarAction );

    _fullscreenAction = new QAction( trUtf8("Pantalla completa"), this );
    _fullscreenAction->setCheckable( true );
    _fullscreenAction->setShortcut( QKeySequence::FullScreen );
    _fullscreenAction->setStatusTip( trUtf8("Alternar pantalla completa") );
    _fullscreenAction->setShortcutContext( Qt::ApplicationShortcut );
    connect( _fullscreenAction, SIGNAL( triggered() ), this, SLOT( toggleFullscreen() ) );
    addAction( _fullscreenAction );

    _sortActions = new QActionGroup( this );
    connect( _sortActions, SIGNAL( triggered( QAction* ) ), this, SLOT( sort( QAction* ) ) );

    _sortInicioAscAction = new QAction( trUtf8("Ascendente"), _sortActions );
    _sortInicioAscAction->setStatusTip( trUtf8("Ordenar por inicio ascendente") );
    _sortInicioAscAction->setCheckable( true );

    _sortInicioDescAction = new QAction( trUtf8("Descendente"), _sortActions );
    _sortInicioDescAction->setStatusTip( trUtf8("Ordenar por inicio descendente") );
    _sortInicioDescAction->setCheckable( true );

    _sortSitioAscAction = new QAction( trUtf8("Ascendente"), _sortActions );
    _sortSitioAscAction->setStatusTip( trUtf8("Ordenar por sitio ascendente") );
    _sortSitioAscAction->setCheckable( true );

    _sortSitioDescAction = new QAction( trUtf8("Descendente"), _sortActions );
    _sortSitioDescAction->setStatusTip( trUtf8("Ordenar por sitio descendente") );
    _sortSitioDescAction->setCheckable( true );

    _sortDuracionAscAction = new QAction( trUtf8("Ascendente"), _sortActions );
    _sortDuracionAscAction->setStatusTip( trUtf8("Ordenar por duración ascendente") );
    _sortDuracionAscAction->setCheckable( true );

    _sortDuracionDescAction = new QAction( trUtf8("Descendente"), _sortActions );
    _sortDuracionDescAction->setStatusTip( trUtf8("Ordenar por duración descendente") );
    _sortDuracionDescAction->setCheckable( true );

    _sortHoraAscAction = new QAction( trUtf8("Ascendente"), _sortActions );
    _sortHoraAscAction->setStatusTip( trUtf8("Ordenar por hora ascendente") );
    _sortHoraAscAction->setCheckable( true );

    _sortHoraDescAction = new QAction( trUtf8("Descendente"), _sortActions );
    _sortHoraDescAction->setStatusTip( trUtf8("Ordenar por hora descendente") );
    _sortHoraDescAction->setCheckable( true );

    _verMapaToggleAction = new QAction( trUtf8("Mapa"), this );
    _verMapaToggleAction->setShortcut( Qt::Key_F7 );
    _verMapaToggleAction->setStatusTip( trUtf8("Mostrar el mapa de inmersiones") );
    _verMapaToggleAction->setShortcutContext( Qt::ApplicationShortcut );
    _verMapaToggleAction->setCheckable( true );
    _verMapaToggleAction->setChecked( true );
    connect( _verMapaToggleAction, SIGNAL( toggled( bool ) ), this, SLOT( mapaToggle( bool ) ) );
    addAction( _verMapaToggleAction );

    _verEstadisticasAction = new QAction( trUtf8("Estadísticas"), this );
    _verEstadisticasAction->setShortcut( Qt::Key_F8 );
    _verEstadisticasAction->setStatusTip( trUtf8("Mostrar las estadísticas del buceador") );
    _verEstadisticasAction->setShortcutContext( Qt::ApplicationShortcut );
    _verEstadisticasAction->setCheckable( true );
    _verEstadisticasAction->setChecked( true );
    connect( _verEstadisticasAction, SIGNAL( toggled( bool ) ), this, SLOT( estadisticasToggle( bool ) ) );
    addAction( _verEstadisticasAction );

    _verProfundidadAction = new QAction( trUtf8("Profundidad"), this );
    _verProfundidadAction->setShortcut( Qt::Key_F3 );
    _verProfundidadAction->setStatusTip( trUtf8("Ver el gráfico de la profundidad de la inmersión seleccionada") );
    _verProfundidadAction->setShortcutContext( Qt::ApplicationShortcut );
    _verProfundidadAction->setCheckable( true );
    _verProfundidadAction->setChecked( true );
    connect( _verProfundidadAction, SIGNAL( toggled( bool ) ), _inmersionGrafico, SLOT( verProfundidad( bool ) ) );
    connect( _inmersionGrafico, SIGNAL( profundidadEnabled( bool ) ), _verProfundidadAction, SLOT( setChecked( bool ) ) );
    addAction( _verProfundidadAction );

    _verTemperaturaAction = new QAction( trUtf8("Temperatura"), this );
    _verTemperaturaAction->setShortcut( Qt::Key_F4 );
    _verTemperaturaAction->setStatusTip( trUtf8("Ver el gráfico de la temperatura de la inmersión seleccionada") );
    _verTemperaturaAction->setShortcutContext( Qt::ApplicationShortcut );
    _verTemperaturaAction->setCheckable( true );
    connect( _verTemperaturaAction, SIGNAL( toggled( bool ) ), _inmersionGrafico, SLOT( verTemperatura( bool ) ) );
    connect( _inmersionGrafico, SIGNAL( temperaturaEnabled( bool ) ), _verTemperaturaAction, SLOT( setChecked( bool ) ) );
    addAction( _verTemperaturaAction );

    _verPresionAction = new QAction( trUtf8("Presión"), this );
    _verPresionAction->setShortcut( Qt::Key_F5 );
    _verPresionAction->setStatusTip( trUtf8("Ver el gráfico de la presión de la inmersión seleccionada") );
    _verPresionAction->setShortcutContext( Qt::ApplicationShortcut );
    _verPresionAction->setCheckable( true );
    connect( _verPresionAction, SIGNAL( toggled( bool ) ), _inmersionGrafico, SLOT( verPresion( bool ) ) );
    connect( _inmersionGrafico, SIGNAL( presionEnabled( bool ) ), _verPresionAction, SLOT( setChecked( bool ) ) );
    addAction( _verPresionAction );

    _verTasaCasAction = new QAction( trUtf8("Tasa CAS"), this );
    _verTasaCasAction->setShortcut( Qt::Key_F6 );
    _verTasaCasAction->setStatusTip( trUtf8("Ver el gráfico de la tasa de CAS de la inmersión seleccionada") );
    _verTasaCasAction->setShortcutContext( Qt::ApplicationShortcut );
    _verTasaCasAction->setCheckable( true );
    connect( _verTasaCasAction, SIGNAL( toggled( bool ) ), _inmersionGrafico, SLOT( verTasaCAS( bool ) ) );
    connect( _inmersionGrafico, SIGNAL( tasacasEnabled( bool ) ), _verTasaCasAction, SLOT( setChecked( bool ) ) );
    addAction( _verTasaCasAction );

    _verActions = new QActionGroup( this );
    _verActions->addAction( _verProfundidadAction );
    _verActions->addAction( _verTemperaturaAction );
    _verActions->addAction( _verPresionAction );
    _verActions->addAction( _verTasaCasAction );
    _verActions->setEnabled( false );

    _inmersionesListToggleAction = new QAction( trUtf8("Lista de inmersiones"), this );
    _inmersionesListToggleAction->setCheckable( true );
    _inmersionesListToggleAction->setShortcut( Qt::Key_F9 );
    _inmersionesListToggleAction->setStatusTip( trUtf8("Mostrar/ocultar la lista de inmersiones") );
    _inmersionesListToggleAction->setShortcutContext( Qt::ApplicationShortcut );
    connect( _inmersionesListToggleAction, SIGNAL( triggered( bool ) ), this, SLOT( inmersionesListDockToggle( bool ) ) );

    _inmersionDetallesToggleAction = new QAction( trUtf8("Detalles de la inmersión"), this );
    _inmersionDetallesToggleAction->setCheckable( true );
    _inmersionDetallesToggleAction->setShortcut( Qt::Key_F10 );
    _inmersionDetallesToggleAction->setStatusTip( trUtf8("Mostrar/ocultar los detalles de la inmersión") );
    _inmersionDetallesToggleAction->setShortcutContext( Qt::ApplicationShortcut );
    connect( _inmersionDetallesToggleAction, SIGNAL( triggered( bool ) ), this, SLOT( inmersionDetallesDockToggle( bool ) ) );
}

void MainWindow::createMenus()
{
    _archivoMenu = _menubar->addMenu( trUtf8("&Archivo") );
    _archivoMenu->addAction( _importRelojAction );
    _archivoMenu->addAction( _importInmersionesAction );
    _archivoMenu->addAction( _importMuestrasAction );
    _archivoMenu->addSeparator();
    _archivoMenu->addAction( _salirAction );

    _listviewMenu = new QMenu();
    _listviewMenu->addAction( _eliminarAction );

    _ordenarMenu = _listviewMenu->addMenu( trUtf8("Ordenar lista de inmersiones") );

    _inicioMenu = _ordenarMenu->addMenu( trUtf8("Inicio") );
    _inicioMenu->addAction( _sortInicioAscAction );
    _inicioMenu->addAction( _sortInicioDescAction );

    _sitioMenu = _ordenarMenu->addMenu( trUtf8("Sitio") );
    _sitioMenu->addAction( _sortSitioAscAction );
    _sitioMenu->addAction( _sortSitioDescAction );

    _duracionMenu = _ordenarMenu->addMenu( trUtf8("Duración") );
    _duracionMenu->addAction( _sortDuracionAscAction );
    _duracionMenu->addAction( _sortDuracionDescAction );

    _horaMenu = _ordenarMenu->addMenu( trUtf8("Hora") );
    _horaMenu->addAction( _sortHoraAscAction );
    _horaMenu->addAction( _sortHoraDescAction );

    _inmersionesList->setContextMenu( _listviewMenu );

    _verMenu = _menubar->addMenu( trUtf8("&Ver") );
    _verMenu->addAction( _verProfundidadAction );
    _verMenu->addAction( _verTemperaturaAction );
    _verMenu->addAction( _verPresionAction );
    _verMenu->addAction( _verTasaCasAction );
    _verMenu->addSeparator();
    _verMenu->addAction( _verMapaToggleAction );
    _verMenu->addAction( _verEstadisticasAction );
    _verMenu->addSeparator();
    _verMenu->addMenu( _ordenarMenu );
    _verMenu->addSeparator();
    _verMenu->addAction( _inmersionesListToggleAction );
    _verMenu->addAction( _inmersionDetallesToggleAction );
    _verMenu->addSeparator();
    _verMenu->addAction( _fullscreenAction );
}

void MainWindow::createDocks()
{
    _inmersionesListDock = new QDockWidget( trUtf8( "Lista de inmersiones" ), this );
    _inmersionesListDock->setObjectName( "inmersionesListDock" );
    _inmersionesListDock->setAllowedAreas( Qt::LeftDockWidgetArea | Qt::RightDockWidgetArea );
    _inmersionesListDock->setWidget( _inmersionesList );

    _inmersionDetallesStack = new QStackedWidget( this );
    _inmersionDetallesStack->addWidget( new QWidget() );
    _inmersionDetallesStack->addWidget( _inmersionDetalles );

    _inmersionDetallesDock = new QDockWidget( trUtf8( "Detalles de la inmersión" ), this );
    _inmersionDetallesDock->setObjectName( "inmersionDetallesDock" );
    _inmersionDetallesDock->setAllowedAreas( Qt::BottomDockWidgetArea | Qt::TopDockWidgetArea );
    _inmersionDetallesDock->setWidget( _inmersionDetallesStack );

    setCorner( Qt::BottomLeftCorner, Qt::LeftDockWidgetArea );
    setCorner( Qt::TopLeftCorner, Qt::LeftDockWidgetArea );
    setCorner( Qt::BottomRightCorner, Qt::RightDockWidgetArea );
    setCorner( Qt::TopRightCorner, Qt::RightDockWidgetArea );

    addDockWidget( Qt::LeftDockWidgetArea, _inmersionesListDock );
    addDockWidget( Qt::BottomDockWidgetArea, _inmersionDetallesDock );

}
